/**
 * 
 */
package platzerworld.kegeln.db.ergebnis;

import java.util.ArrayList;
import java.util.List;

import platzerworld.kegeln.common.db.Sortierung;
import platzerworld.kegeln.common.logging.LOG;
import platzerworld.kegeln.db.KegelverwaltungDatenbank;
import platzerworld.kegeln.vo.ergebnis.ErgebnisVO;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
import android.util.Log;

/**
 * Der ErgebnisSpeicher ist die Schnittstelle zu persistenten Ergebnisdaten.
 * 
 * Die Ergebnisdaten sind in der Anwendungsdatenbank abgelegt. 
 * Die Anwendung sollte nur über den ErgebnisSpeicher auf gespeicherte Ergebnisse zugreifen.
 * Um den ErgebnisSpeicher erzeugen zu können, muss die aufrufende Android-Komponente ihren Context übergeben.
 * 
 * @author platzerg
 */
public class ErgebnisSpeicher {

	/** Markierung für Logging. */
	private static final String TAG = "ErgebnisSpeicher";

	/** Verweis auf die Kegelverwaltung-Datenbank. */
	private KegelverwaltungDatenbank mDb;

	/**
	 * Erzeugt einen neuen MannschaftSpeicher. Dabei wird sichergestellt, dass
	 * die zugrundeliegende Datenbank unmittelbar nutzbar ist.
	 * 
	 * @param context
	 *            Kontext der Anwendung, f�r die der Speicher g�ltig sein soll.
	 */
	public ErgebnisSpeicher(Context context) {
		mDb = new KegelverwaltungDatenbank(context);
		LOG.v(TAG, "Ergebnisspeicher angelegt.");
	}

	/**
	 * Erzeugung ohne Context nicht m�glich.
	 */
	private ErgebnisSpeicher() {
	}
	
	public long speichereErgebnis(ErgebnisVO ergebnisVO) {
		if (ergebnisVO.istNeu()) {
			return speichereErgebnisAllColumns(ergebnisVO);
		} else {
			aendereErgebnis(ergebnisVO);
			return ergebnisVO.key;
		}
	}

	/**
	 * Legt ein neues Ergebnis in der Datenbank an.
	 * 
	 * ergebnisVO Value-Object ErgebnisVO
	 * @return Datenbank-Id des neuen Ergebnisses
	 * @throws SQLException falls Speichern nicht möglich.
	 */
	public long speichereErgebnisAllColumns(ErgebnisVO ergebnisVO) {

		final ContentValues daten = new ContentValues();
		daten.put(ErgebnisTbl.SPIEL_ID, ergebnisVO.spielId);
		daten.put(ErgebnisTbl.SPIEL_ZEIT, ergebnisVO.spielZeit);
		daten.put(ErgebnisTbl.SPIELER_ID, ergebnisVO.spielerId);
		daten.put(ErgebnisTbl.MANNSCHAFT_ID, ergebnisVO.mannschaftId);
		daten.put(ErgebnisTbl.GESAMT_ERGEBNIS, ergebnisVO.gesamtergebnis);

		daten.put(ErgebnisTbl.ERGEBNIS_50_1, ergebnisVO.ergebnis501);
		daten.put(ErgebnisTbl.ERGEBNIS_50_2, ergebnisVO.ergebnis502);

		daten.put(ErgebnisTbl.VOLLE_25_1, ergebnisVO.volle251);
		daten.put(ErgebnisTbl.VOLLE_25_2, ergebnisVO.volle252);

		daten.put(ErgebnisTbl.ABRAEUMEN_25_1, ergebnisVO.abraeumen251);
		daten.put(ErgebnisTbl.ABRAEUMEN_25_2, ergebnisVO.abraeumen252);

		daten.put(ErgebnisTbl.FEHL_25_1, ergebnisVO.fehl251);
		daten.put(ErgebnisTbl.FEHL_25_2, ergebnisVO.fehl252);

		final SQLiteDatabase dbCon = mDb.getWritableDatabase();

		try {
			final long id = dbCon.insertOrThrow(ErgebnisTbl.TABLE_NAME, null, daten);
			Log.i(TAG, "Ergebnis mit id=" + id + " erzeugt.");
			return id;
		} finally {
			dbCon.close();
		}
	}

	/**
	 * Änderung des Ergebnisses.
	 * 
	 * @param ergebnisVO Value-Object ErgebnisVO
	 */
	private void aendereErgebnis(ErgebnisVO ergebnisVO) {
		if (ergebnisVO.key == 0) {
			Log.w(TAG, "id == 0 => kein update möglich.");
			return;
		}

		final ContentValues daten = new ContentValues();
		daten.put(ErgebnisTbl.SPIEL_ID, ergebnisVO.spielId);
		daten.put(ErgebnisTbl.SPIEL_ZEIT, ergebnisVO.spielZeit);
		daten.put(ErgebnisTbl.SPIELER_ID, ergebnisVO.spielerId);
		daten.put(ErgebnisTbl.MANNSCHAFT_ID, ergebnisVO.mannschaftId);
		daten.put(ErgebnisTbl.GESAMT_ERGEBNIS, ergebnisVO.gesamtergebnis);

		daten.put(ErgebnisTbl.ERGEBNIS_50_1, ergebnisVO.ergebnis501);
		daten.put(ErgebnisTbl.ERGEBNIS_50_2, ergebnisVO.ergebnis502);

		daten.put(ErgebnisTbl.VOLLE_25_1, ergebnisVO.volle251);
		daten.put(ErgebnisTbl.VOLLE_25_2, ergebnisVO.volle252);

		daten.put(ErgebnisTbl.ABRAEUMEN_25_1, ergebnisVO.abraeumen251);
		daten.put(ErgebnisTbl.ABRAEUMEN_25_2, ergebnisVO.abraeumen252);

		daten.put(ErgebnisTbl.FEHL_25_1, ergebnisVO.fehl251);
		daten.put(ErgebnisTbl.FEHL_25_2, ergebnisVO.fehl252);

		final SQLiteDatabase dbCon = mDb.getWritableDatabase();

		try {
			dbCon.update(ErgebnisTbl.TABLE_NAME, daten, ErgebnisTbl.WHERE_ID_EQUALS,
					new String[] { String.valueOf(ergebnisVO.key) });
			Log.i(TAG, "Ergebnis id=" + ergebnisVO.key + " aktualisiert.");
		} finally {
			dbCon.close();
		}
	}

	/**
	 * Entfernt ein Ergebnis aus der Datenbank.
	 * 
	 * @param id Schlüssel des gesuchten Ergebnisses
	 * @return true, wenn Datensatz geloescht wurde.
	 */
	public boolean loescheErgebnis(long id) {
		final SQLiteDatabase dbCon = mDb.getWritableDatabase();

		int anzahlLoeschungen = 0;
		try {
			anzahlLoeschungen = dbCon.delete(ErgebnisTbl.TABLE_NAME, ErgebnisTbl.WHERE_ID_EQUALS,
					new String[] { String.valueOf(id) });
			Log.i(TAG, "Ergebnis id=" + id + " gelö�scht.");
		} finally {
			dbCon.close();
		}
		return anzahlLoeschungen == 1;
	}
	
	/**
	 * Entfernt ein Ergebnis aus der Datenbank.
	 * 
	 * @param spielId SpielID
	 * @return true, wenn Datensatz geloescht wurde.
	 */
	public boolean loescheErgebnisBySpielId(long spielId) {
		final SQLiteDatabase dbCon = mDb.getWritableDatabase();

		int anzahlLoeschungen = 0;
		try {
			anzahlLoeschungen = dbCon.delete(ErgebnisTbl.TABLE_NAME, ErgebnisTbl.WHERE_SPIEL_ID_EQUALS,
					new String[] { String.valueOf(spielId) });
			Log.i(TAG, "Ergebnis id=" + spielId + " gelöscht.");
		} finally {
			dbCon.close();
		}
		return anzahlLoeschungen == 1;
	}

	/**
	 * Liefert einen Cursor auf alle Felder der Ergebnis-Tabelle zurück. Wenn
	 * ein komplettes Ergebnis genutzt werden soll, ist die ladeErgebnis-Methode vorzuziehen.
	 * 
	 * @param id Schlüssel des gesuchten Ergebnisses
	 * @return Cursor, oder null
	 */
	public Cursor ladeErgebnis(long id) {
		return mDb.getReadableDatabase().query(ErgebnisTbl.TABLE_NAME, ErgebnisTbl.ALL_COLUMNS,
				ErgebnisTbl.WHERE_ID_EQUALS, new String[] { String.valueOf(id) }, null, null, null);
	}

	/**
	 * Liefert ein Value-Object ErgebnisVO mit allen Feldern der Ergebnis-Tabelle zurück.
	 * 
	 * @param id Schüssel des gesuchten Ergebnisses
	 * @return ErgebnisVO, oder null
	 */
	public ErgebnisVO ladeErgebnisVO(long id) {
		ErgebnisVO ergebnisVO = null;
		Cursor c = null;
		try {
			c = mDb.getReadableDatabase().query(ErgebnisTbl.TABLE_NAME, ErgebnisTbl.ALL_COLUMNS,
					ErgebnisTbl.WHERE_ID_EQUALS, new String[] { String.valueOf(id) }, null, null, null);
			if (c.moveToFirst() == false) {
				return null;
			}
			ergebnisVO = ladeErgebnis(c);
		} finally {
			if (c != null) {
				c.close();
			}
		}
		return ergebnisVO;
	}

	/**
	 * Liefert einen Cursor auf alle Felder der Ergebnis-Tabelle zurück.
	 * 
	 * @param spielId SpielId des Ergebnisses
	 * @return Cursor, oder null
	 */
	public Cursor ladeErgebnisDetails(long spielId) {
		return mDb.getReadableDatabase().query(ErgebnisTbl.TABLE_NAME, ErgebnisTbl.ALL_COLUMNS, ErgebnisTbl.WHERE_SPIEL_ID_EQUALS,
				new String[] { String.valueOf(spielId) }, null, null, ErgebnisTbl.DEFAULT_SORT_ORDER);
	}

	/**
	 * Liefert alle Ergebnisse sortiert nach Name zurück.
	 * 
	 * Es kann (optional) ein Filterkriterium angegeben werden. Wenn der
	 * namensFilterdefiniert ist, werden nur Ergebnisse geliefert, deren NAME mit
	 * diesem Buchstaben beginnt.
	 * 
	 * @param namensFilter Anfangsbuchstaben (case sensitive) des zu suchenden Ergebnisses.
	 * @return Cursor auf die Ergebnisliste.
	 */
	public Cursor ladeErgebnisListe(CharSequence namensFilter) {
		return ladeErgebnisListe(Sortierung.STANDARD, namensFilter);
	}

	/**
	 * Liefert alle Ergebnisse zur spielerID und Namensfilter.
	 * 
	 * @param namensFilter Anfangsbuchstaben (case sensitive) der zu suchenden Kontakte.
	 * @param klasseId spielerId der zu suchenden Kontakte.
	 * @return Cursor auf die Ergebnisliste.
	 */
	public Cursor ladeErgebnisZumSpieler(CharSequence namensFilter, long spielerId) {
		return ladeErgebnisZumSpielerListe(Sortierung.ID, namensFilter, spielerId);
	}

	/**
	 * Liefert alle Ergebnisse zur spielerID
	 * 
	 * @param spielerId SpielerID
	 * @return Cursor auf die Ergebnisliste.
	 */
	public List<ErgebnisVO> ladeErgebnisZumSpielerListeVO(long spielerId) {
		return ladeMannschaftZumSpielerListeVO(Sortierung.ID, spielerId);
	}

	/**
	 * Liefert alle Ergebnisse zum Namensfilter.
	 * 
	 * @param namensFilter Anfangsbuchstaben (case sensitive) der zu suchenden Kontakte.
	 * @return Cursor auf die Ergebnisliste.
	 */
	public List<ErgebnisVO> ladeErgebnisListeVO(CharSequence namensFilter) {
		return ladeErgebnisListeVO(Sortierung.ID, namensFilter);
	}

	/**
	 * Liefert alle Ergebnisse mit einstellbarer Sortierung  zurück.
	 * 
	 * @param sortierung Art der Sortierung
	 * @param namensFilter Anfangsbuchstaben (case sensitive) der zu suchenden Kontakte.
	 * @return Cursor auf die Ergebnisliste.
	 */
	public List<ErgebnisVO> ladeErgebnisListeVO(Sortierung sortierung, CharSequence namensFilter) {
		final SQLiteQueryBuilder ergebnisSuche = new SQLiteQueryBuilder();
		ergebnisSuche.setTables(ErgebnisTbl.TABLE_NAME);

		String[] whereAttribs = null;
		if (namensFilter != null && namensFilter.length() > 0) {
			ergebnisSuche.appendWhere( ErgebnisTbl.WHERE_SPIEL_LIKE);
			whereAttribs = new String[] { namensFilter + "%" };
		}
		Cursor ergebnisCursor = ergebnisSuche.query(mDb.getReadableDatabase(), ErgebnisTbl.ALL_COLUMNS, null,
				whereAttribs, null, null, getErgebnisSortierung(sortierung));

		return ladeErgebnisKeyValueVO(ergebnisCursor);
	}

	/**
	 * Liefert alle Ergebnisse zur KlassenId und mit einstellbarer Sortierung zurück.
	 * 
	 * @param sortierung Art der Sortierung
	 * @param namensFilter Anfangsbuchstaben (case sensitive) der zu suchenden Kontakte.
	 * @param klasseId KlassenId
	 * @return Cursor auf die Ergebnisliste.
	 */
	public List<ErgebnisVO> ladeMannschaftZumSpielerListeVO(Sortierung sortierung, long klasseId) {
		SQLiteDatabase d = mDb.getReadableDatabase();
		Cursor mannschaftCursor = d.query(ErgebnisTbl.TABLE_NAME, ErgebnisTbl.ALL_COLUMNS, ErgebnisTbl.SPIELER_ID + "="
				+ String.valueOf(klasseId), null, null, null, null);

		return ladeErgebnisKeyValueVO(mannschaftCursor);
	}

	/**
	 * Lädt die Ergebnisse aus dem ErgebnisTbl-Datensatz, auf dem der Cursor gerade steht.
	 * 
	 * Der Cursor wird anschließend deaktiviert, da er im ErgebnisSpeicher nur intern als "letzter Aufruf" aufgerufen wird.
	 * 
	 * @param c aktuelle Cursorposition != null
	 * @return ArrayList<ErgebnisVO> ergebnisse
	 */
	public ArrayList<ErgebnisVO> ladeErgebnisKeyValueVO(Cursor c) {
		ArrayList<ErgebnisVO> ergebnisseVO = new ArrayList<ErgebnisVO>();
		ErgebnisVO ergebnisVO = null;
		if (c != null) {
			if (c.moveToFirst()) {
				do {
					ergebnisVO = new ErgebnisVO();
					ergebnisVO.key = c.getLong(c.getColumnIndex(ErgebnisTbl.ID));
					
					ergebnisVO.spielId = c.getLong(c.getColumnIndex(ErgebnisTbl.SPIEL_ID));
					ergebnisVO.spielerId = c.getLong(c.getColumnIndex(ErgebnisTbl.SPIELER_ID));
					ergebnisVO.spielZeit = c.getString(c.getColumnIndex(ErgebnisTbl.SPIEL_ZEIT));
					ergebnisVO.gesamtergebnis = c.getLong(c.getColumnIndex(ErgebnisTbl.GESAMT_ERGEBNIS));
					ergebnisVO.ergebnis501 = c.getLong(c.getColumnIndex(ErgebnisTbl.ERGEBNIS_50_1));
					ergebnisVO.ergebnis502 = c.getLong(c.getColumnIndex(ErgebnisTbl.ERGEBNIS_50_2));

					ergebnisVO.volle251 = c.getLong(c.getColumnIndex(ErgebnisTbl.VOLLE_25_1));
					ergebnisVO.abraeumen251 = c.getLong(c.getColumnIndex(ErgebnisTbl.ABRAEUMEN_25_1));
					ergebnisVO.fehl251 = c.getLong(c.getColumnIndex(ErgebnisTbl.FEHL_25_1));

					ergebnisVO.volle252 = c.getLong(c.getColumnIndex(ErgebnisTbl.VOLLE_25_2));
					ergebnisVO.abraeumen252 = c.getLong(c.getColumnIndex(ErgebnisTbl.ABRAEUMEN_25_2));
					ergebnisVO.fehl252 = c.getLong(c.getColumnIndex(ErgebnisTbl.FEHL_25_2));

					ergebnisseVO.add(ergebnisVO);
				} while (c.moveToNext());
			}
		}

		return ergebnisseVO;
	}

	/**
	 * Liefert alle Ergebnisse mit einstellbarer Sortierung zurück. 
	 * Es kann (optional) ein Filterkriterium angegeben werden. Wenn der namensFilter definiert ist, 
	 * werden nur Kontakte geliefert, deren NAME mit diesem Buchstaben beginnt.
	 * 
	 * @param sortierung Art der Sortierung
	 * @param namensFilterAnfangsbuchstaben (case sensitive) des zu suchenden Ergebnisses.
	 * @return Cursor auf die Ergebnisliste.
	 */
	public Cursor ladeErgebnisListe(Sortierung sortierung, CharSequence namensFilter) {
		final SQLiteQueryBuilder ergebnisSuche = new SQLiteQueryBuilder();
		ergebnisSuche.setTables(ErgebnisTbl.TABLE_NAME);
		String[] whereAttribs = null;
		if (namensFilter != null && namensFilter.length() > 0) {
			ergebnisSuche.appendWhere(ErgebnisTbl.WHERE_SPIEL_ID_EQUALS);
			whereAttribs = new String[] { namensFilter + "%" };
		}

		return ergebnisSuche.query(mDb.getReadableDatabase(), ErgebnisTbl.ALL_COLUMNS, null, whereAttribs, null, null,
				getErgebnisSortierung(sortierung));
	}

	/**
	 * Liefert alle Ergebnisse zur SpielerId und mit einstellbarer Sortierung zurück.
	 * 
	 * @param sortierung  Art der Sortierung
	 * @param namensFilter Anfangsbuchstaben (case sensitive) der zu suchenden Kontakte.
	 * @param SpielerId SpielerID
	 * @return Cursor auf die Ergebnisliste.
	 */
	public Cursor ladeErgebnisZumSpielerListe(Sortierung sortierung, CharSequence namensFilter, long SpielerId) {
		SQLiteDatabase d = mDb.getReadableDatabase();
		Cursor mannschaftCursor = d.query(ErgebnisTbl.TABLE_NAME, ErgebnisTbl.ALL_COLUMNS, ErgebnisTbl.SPIELER_ID + "="
				+ String.valueOf(SpielerId), null, null, null, null);

		mannschaftCursor.getCount();
		mannschaftCursor.moveToFirst();

		return mannschaftCursor;
	}

	/**
	 * Lädt die Ergebnisse aus dem ErgebnisTbl-Datensatz, auf dem der Cursor gerade steht.
	 * 
	 * Der Cursor wird anschließend deaktiviert, da er im ErgebnisSpeicher nur intern als "letzter Aufruf" aufgerufen wird.
	 * 
	 * @param c aktuelle Cursorposition
	 * @return List<String[]> ergebnisse
	 */
	public List<String[]> ladeErgebnisAsStringArray() {
		Cursor c = null;
		List<String[]> ergebnisAsArray = new ArrayList<String[]>();
		
		try{
			c = ladeErgebnisListe(null);
			
			if (c != null ) {
	    		if  (c.moveToFirst()) {
	    			do {    	
	    				String[] ergebnisZeile = new String[14];
	    				// ID, SPIEL_ID, SPIELER_ID, MANNSCHAFT_ID, SPIEL_ZEIT, ERGEBNIS_50_1, ERGEBNIS_50_2, VOLLE_25_1, VOLLE_25_2, 
	    				// ABRAEUMEN_25_1, ABRAEUMEN_25_2, FEHL_25_1,  FEHL_25_2GESAMT_ERGEBNIS, 
	    				ergebnisZeile[0] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.ID)));
	    				ergebnisZeile[1] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.SPIEL_ID)));
	    				ergebnisZeile[2] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.SPIELER_ID)));
	    				ergebnisZeile[3] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.MANNSCHAFT_ID)));
	    				ergebnisZeile[4] = c.getString(c.getColumnIndex(ErgebnisTbl.SPIEL_ZEIT));
	    				ergebnisZeile[5] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.ERGEBNIS_50_1)));
	    				ergebnisZeile[6] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.ERGEBNIS_50_2)));	    				
	    				ergebnisZeile[7] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.VOLLE_25_1)));
	    				ergebnisZeile[8] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.VOLLE_25_2)));
	    				ergebnisZeile[9] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.ABRAEUMEN_25_1)));
	    				ergebnisZeile[10] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.ABRAEUMEN_25_2)));
	    				ergebnisZeile[11] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.FEHL_25_1)));	    
	    				ergebnisZeile[12] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.FEHL_25_2)));
	    				ergebnisZeile[13] = String.valueOf(c.getLong(c.getColumnIndex(ErgebnisTbl.GESAMT_ERGEBNIS)));
	    				
	    				
	    				ergebnisAsArray.add(ergebnisZeile);
	    			}while (c.moveToNext());
	    		} 
	    	}
		} finally {
			if (c != null) {
				c.close();
			}
		}
		

		return ergebnisAsArray;
	}
	
	/**
	 * Liefert die Sortierung unter Berücksichtigung der Standard-Sortierung der Ergebnistabelle.
	 * 
	 * @param sortierung Sortierung als enum.
	 * @return Sortierung als ORDER_BY kompatible Anweisung.
	 */
	private static String getErgebnisSortierung(Sortierung sortierung) {
		String sortiertNach = ErgebnisTbl.DEFAULT_SORT_ORDER;
		switch (sortierung) {
		case GESAMT_ERGEBNIS:
			sortiertNach = ErgebnisTbl.GESAMT_ERGEBNIS;
			break;
		case ID:
			sortiertNach = ErgebnisTbl.ID;
			break;
		default:
			break;
		}
		return sortiertNach;
	}

	/**
	 * Lädt die Ergebnisse aus dem ErgebnisTbl-Datensatz, auf dem der Cursor gerade steht.
	 * 
	 * Der Cursor wird anschließend deaktiviert, da er im ErgebnisSpeicher nur intern als "letzter Aufruf" aufgerufen wird.
	 * 
	 * @param c aktuelle Cursorposition != null
	 * @return ErgebnisVO
	 */
	public ErgebnisVO ladeErgebnis(Cursor c) {
		final ErgebnisVO ergebnisVO = new ErgebnisVO();

		ergebnisVO.key = c.getLong(c.getColumnIndex(ErgebnisTbl.ID));
		
		ergebnisVO.spielId = c.getLong(c.getColumnIndex(ErgebnisTbl.SPIEL_ID));
		ergebnisVO.spielerId = c.getLong(c.getColumnIndex(ErgebnisTbl.SPIELER_ID));
		ergebnisVO.spielZeit = c.getString(c.getColumnIndex(ErgebnisTbl.SPIEL_ZEIT));
		ergebnisVO.gesamtergebnis = c.getLong(c.getColumnIndex(ErgebnisTbl.GESAMT_ERGEBNIS));
		ergebnisVO.ergebnis501 = c.getLong(c.getColumnIndex(ErgebnisTbl.ERGEBNIS_50_1));
		ergebnisVO.ergebnis502 = c.getLong(c.getColumnIndex(ErgebnisTbl.ERGEBNIS_50_2));

		ergebnisVO.volle251 = c.getLong(c.getColumnIndex(ErgebnisTbl.VOLLE_25_1));
		ergebnisVO.abraeumen251 = c.getLong(c.getColumnIndex(ErgebnisTbl.ABRAEUMEN_25_1));
		ergebnisVO.fehl251 = c.getLong(c.getColumnIndex(ErgebnisTbl.FEHL_25_1));

		ergebnisVO.volle252 = c.getLong(c.getColumnIndex(ErgebnisTbl.VOLLE_25_2));
		ergebnisVO.abraeumen252 = c.getLong(c.getColumnIndex(ErgebnisTbl.ABRAEUMEN_25_2));
		ergebnisVO.fehl252 = c.getLong(c.getColumnIndex(ErgebnisTbl.FEHL_25_2));
		
		ergebnisVO.mannschaftId = c.getLong(c.getColumnIndex(ErgebnisTbl.MANNSCHAFT_ID));

		return ergebnisVO;
	}

	/**
	 * Schliesst die zugrundeliegende Datenbank. Vor dem naechsten Zugriff muss oeffnen() aufgerufen werden.
	 */
	public void schliessen() {
		mDb.close();
		LOG.v(TAG, "Datenbank kegelverwaltung geschlossen.");
	}

	/**
	 * Oeffnet die Datenbank, falls sie vorher mit schliessen() geschlossenwurde. 
	 * Bei Bedarf wird das Schema angelegt bzw. aktualisiert.
	 */
	public void oeffnen() {
		mDb.getReadableDatabase();
		LOG.v(TAG, "Datenbank kegelverwaltung geoeffnet.");
	}

	/**
	 * Oeffnet die Datenbank schreibbar, falls sie vorher mit schliessen()
	 * geschlossen wurde. Bei Bedarf wird das Schema angelegt bzw. aktualisiert.
	 */
	public void oeffnenSchreibzugriff() {
		mDb.getWritableDatabase();
		LOG.v(TAG, "Datenbank kegelverwaltung schreibend geoeffnet.");
	}

	/**
	 * Gibt die Anzahl der Ergebnisse in der Datenbank zurueck.
	 * Performanter als Cursor::getCount.
	 * 
	 * @return Anzahl der Mannschaften.
	 */
	public int anzahlErgebnisse() {
		final Cursor c = mDb.getReadableDatabase().rawQuery("select count(*) from " + ErgebnisTbl.TABLE_NAME, null);
		if (c.moveToFirst() == false) {
			return 0;
		}
		return c.getInt(0);
	}

}
